With the power of today's application development tools, a developer can create a custom application more quickly than ever. However, there is a significant hurdle getting those applications to the desktop due to file and other shared resource conflicts.
Software conflicts oftentimes arise when multiple software applications modify a shared resource such as a file, registry key, or icon that is being used by another application that is installed on the same computer.
Anyone managing the distribution of applications to users has very likely experienced what is commonly referred to as “DLL Hell.” Simply put, DLL hell occurs when one program disables others by installing an incompatible dynamic link library, or DLL, file. This corrupts one's system in one of two ways. In the first instance, an application installs an older DLL over a newer one. The second instance occurs when a newer DLL is properly installed but an application won't work with the new version. In addition, other non-file system resources such as the registry, icons, or system services may be replaced with incompatible versions.
Independent software vendors distribute the DLLs and other support files they've tested during development. However, newer support files that already exist on the destination computer may already have superseded these by the time users load them.
In theory, a vendor's installation routine should double-check to see if a newer version of a shared DLL is already on the target system. Yet vendors have been sloppy or overly cautious about this. On the sloppy side of the equation, some installation routines simply don't check for existing DLLs. In the interest of caution, though, some vendors intend to copy the specific DLL that they've tested, which gives them some cause for confidence. Copying older DLL versions means the newly installed application will work, but applications that rely on later versions of the DLL are now more likely to encounter problems.
Even if the newer version of the shared component copies over older versions there can be problems. It is not always the case that an updated version of a shared component will be completely backward compatible.
In addition, the version information associated with shared files is not always accurate. In many cases, there are multiple indications of the version of a file. The last date/time the file was modified can be used to indicate the version of the file. In addition, many files include one or more internal version numbers. Problems occur when the different version numbers for a file are in error or disagree with each other.
The file system namespace readily allows collisions. Vendors currently tend to throw many of their support files into a common directory such as the System directory. Further, even though Microsoft's 32-bit OSes allow long filenames, most vendors stick to the 8.3 convention; they must if their DLLs are also for 16-bit environments. Plus, their files may someday reside on a shared network drive that supports only short names.
There are only so many eight-character names—fewer when you use meaningful abbreviations and short words. When two developers use a name like DISPLAY.DLL, conflicts occur.
End users are often unaware that underlying system-level components have changed. Loading something like an Internet Explorer browser update can update low-level OS components—the lowest-level TCP/IP protocol stack DLLs, for example. There may be no direct relation; Microsoft may have used the update to slipstream a number of OS patches.
The result is that it becomes harder for vendors to support their products because it is difficult to tell exactly what set of system DLLs any given user has. Developers dislike working in the Microsoft environment right now describing it as a “snake pit” from a support standpoint because they don't know what their customers have.
This problem has been very difficult to prevent and identify until it is too late, resulting in system failures and significant user downtime. DLLs represent only one of several file conflicts that may occur. Conflicts can also occur at different levels in registry keys, components, paths, and drivers making the problem all the more complex.
Accordingly, there is a need for an improved method of identifying and resolving file, registry and other shared component conflicts between multiple applications.
The Kullick et al. U.S. Pat. No. 5,764,992 provides for a method and apparatus for automatic software replacement. An automated software upgrade method is described which allows a software program to determine if it and its associated programs are the newest versions and to replace themselves if necessary.
The Gerken et al. U.S. Pat. No. 5,787,444 provides for a method and apparatus for maintaining revision control of a set of objects within a data processing system. In the context of software revision control, an object oriented method of maintaining control of hierarchically linked data is described.
The Alderson et al. U.S. Pat. No. 5,019,963 provides for a data processing network with upgrading of files. A central host is described which maintains a list of files accessible by a remote client and provides the most current version when a client so requests.
The Holmes et al. U.S. Pat. No. 5,247,683 provides for a system and method for installing software and updating configuration files. A method of maintaining a system's configuration file is described which automatically determines how to update an existing configuration file to accommodate a new application.
The Halliwell et al. U.S. Pat. No. 5,564,051 provides for an automatic update of static and dynamic files at a remote network node in response to calls issued by or for application programs. An application management system is described which identifies and replaces out-of-date files and augments or creates files which are needed.
The Fitzgerald et al. U.S. Pat. No. 5,581,764 discloses a distributed computer network including hierarchical resource information structure and a related method of distributing resources.
The following patens are also relevant: U.S. Pat. No. 4,558,413 to Schmidt et al.; U.S. Pat. No. 4,809,170 to Leblang et al.; U.S. Pat. No. 5,155,847 to Kirouac et al.; U.S. Pat. No. 5,574,898 to Leblang et al.; and U.S. Pat. No. 5,603,027 to Ohkami.